#pragma once

#include <iostream>
#include <vector>
#include <string>
#include <unistd.h>
#include <functional>

namespace ThreadMoudle
{
    class ThreadData
    {
    public:
        ThreadData(const std::string &name, pthread_mutex_t *mutex)
            : _name(name), _mutex(mutex)
        {
        }

    public:
        std::string _name;
        pthread_mutex_t *_mutex;
    };

    typedef void (*func_t)(ThreadData *td);

    class Thread
    {
    public:
        void Excute()
        {
            // std::cout << _td->_name << " is running." << std::endl;
            _running = true;
            _func(_td);
            _running = false;
        }

        // typedef void (*func_t)(const std::string &name);

        Thread(const std::string &name, func_t func, ThreadData *td)
            : _name(name), _func(func), _td(td)
        {
            std::cout << "create td->name " << td->_name << "  succeed." << std::endl;
        }

        static void *ThreadRoutine(void *args)
        {
            Thread *thread = static_cast<Thread *>(args);
            thread->Excute();
            return nullptr;
        }
        bool start()
        {
            // std::cout << "start td->name:" << _td->_name << std::endl;             // 这里就出了问题
            int n = ::pthread_create(&_tid, nullptr, ThreadRoutine, (void *)this); // 所有新线程都会执行该方法
            if (n == 0)
                return true;
            else
                return false;
        }

        void join()
        {
            ::pthread_join(_tid, nullptr);
            std::cout << _name << " join succeed" << std::endl;
            delete _td;
        }

        std::string Name()
        {
            return _name;
        }
        void stop()
        {
            if (_running)
            {
                pthread_cancel(_tid);
                _running = false;
                std::cout << _name << " stop" << std::endl;
            }
        }
        ~Thread()
        {
        }

    private:
        pthread_t _tid;
        std::string _name;
        bool _running;
        func_t _func;
        ThreadData *_td;
    };
}

// #include <iostream>
// #include <string>
// #include <pthread.h>

// namespace ThreadMoudle
// {
//     class ThreadData
//     {
//     public:
//         ThreadData(const std::string &name, pthread_mutex_t *lock):_name(name), _lock(lock)
//         {}
//     public:
//         std::string _name;
//         pthread_mutex_t *_lock;
//     };

//     // 线程要执行的方法，后面我们随时调整
//     typedef void (*func_t)(ThreadData *td); // 函数指针类型

//     class Thread
//     {
//     public:
//         void Excute()
//         {
//             std::cout << _name << " is running" << std::endl;
//             _isrunning = true;
//             _func(_td);
//             _isrunning = false;
//         }
//     public:
//         Thread(const std::string &name, func_t func, ThreadData *td):_name(name), _func(func), _td(td)
//         {
//             std::cout << "create " << name << " done" << std::endl;
//         }
//         static void *ThreadRoutine(void *args) // 新线程都会执行该方法！
//         {
//             Thread *self = static_cast<Thread*>(args); // 获得了当前对象
//             self->Excute();
//             return nullptr;
//         }
//         bool Start()
//         {
//             int n = ::pthread_create(&_tid, nullptr, ThreadRoutine, this);
//             if(n != 0) return false;
//             return true;
//         }
//         std::string Status()
//         {
//             if(_isrunning) return "running";
//             else return "sleep";
//         }
//         void Stop()
//         {
//             if(_isrunning)
//             {
//                 ::pthread_cancel(_tid);
//                 _isrunning = false;
//                 std::cout << _name << " Stop" << std::endl;
//             }
//         }
//         void Join()
//         {
//             ::pthread_join(_tid, nullptr);
//             std::cout << _name << " Joined" << std::endl;
//             delete _td;
//         }
//         std::string Name()
//         {
//             return _name;
//         }
//         ~Thread()
//         {
//         }

//     private:
//         std::string _name;
//         pthread_t _tid;
//         bool _isrunning;
//         func_t _func; // 线程要执行的回调函数
//         ThreadData *_td;
//     };
// } // namespace ThreadModle
